#!/usr/bin/perl
# IBM_PROLOG_BEGIN_TAG 
# This is an automatically generated prolog. 
#  
#  
#  
# Licensed Materials - Property of IBM 
#  
# (C) COPYRIGHT International Business Machines Corp. 2000,2004 
# All Rights Reserved 
#  
# US Government Users Restricted Rights - Use, duplication or 
# disclosure restricted by GSA ADP Schedule Contract with IBM Corp. 
#  
# IBM_PROLOG_END_TAG 
# @(#)80   1.28.1.228   src/csm/install/installms.perl, setup, csm_rameh, rameh0431a 6/28/04 16:22:09
#--------------------------------------------------------------------------------

=head1    installms.perl

	Installs CSM on Linux managment servers

	Notes:  

	AIX code removed

=cut

#--------------------------------------------------------------------------------

=head3  File header

        Notes:

          file header gathers pkgdefs values.

=cut

#--------------------------------------------------------------------------------

use strict;
BEGIN { $::csmpm = $ENV{'CSM_PM'} ? $ENV{'CSM_PM'} : '/opt/csm/pm'; }
use lib $::csmpm;
use File::Path;

# Provides mkpath();
use FindBin qw($Bin);
use lib "$Bin";

use Getopt::Std;
use NodeUtils;
use CSMDefs;

use InstallUtils;

$::MSGCAT     = 'csmInstall.cat';
$::MSGMAPPATH = $ENV{'CSM_MSGMAPS'} ? $ENV{'CSM_MSGMAPS'} : '/opt/csm/msgmaps';
$::MSGSET     = 'csminstall';

#--------------------------------------------------------------------------------

=head3	initialize

	initializes globals from package defs

=cut

#--------------------------------------------------------------------------------

sub initialize
{

    # 0 = tftp server rpm not installed.
    $::default_tftp_server_installed = 0;

    $::command_line;
    $::COPY_OPT_FLAG;
    %::PackageVersionName          = ();
    %::PackageVersionName_Server   = ();
    %::PackageVersionName_Node     = ();
    %::PathVersionName             = ();
    %::CmdLinePathVersionName      = ();
    %::temp_CmdLinePathVersionName = ();
    @::RpmsNotFoundInCmdPath       = ();
    @::Rpms_to_be_copied           = ();
    @::Rpms_not_found              = ();

    #  OS Definitions
    my %OSDefs = ServerUtils->get_OSDefs();

    $::PREREQS_ATTR{'OSName'} = NodeUtils->get_OSName;
    my $OSName = $::PREREQS_ATTR{'OSName'};

    # NLS hack
    if ($ENV{LANG} =~ /^(C|POSIX|en_US)/) { $::ENGLISH = 1; }

    # installms is not supported on AIX management servers
    if ($OSName eq "AIX")
    {
        NodeUtils->message('E', 'EMsgAIXandInstallms');
        exit 1;
    }

    # processor
    $::PREREQS_ATTR{'PkgArchitecture'} = NodeUtils->get_PkgArchitecture;
    if ($::PREREQS_ATTR{'PkgArchitecture'} =~ /i.86/)
    {
        $::PREREQS_ATTR{'PkgArchitecture'} = "i386";
    }

    # CSM version
    $::PREREQS_ATTR{'CsmCoreVersion'} = NodeUtils->get_CSMVersion("csm\.core");
    if (length($::PREREQS_ATTR{'CsmCoreVersion'}) == 0)
    {
        NodeUtils->message('E2', 'EMsgNO_CORE');
    }

    @::VALID_ATTRS = ("RemoteShell", "SetupRemoteShell");
    $::PREREQS_ATTR{'DistributionName'}    = NodeUtils->get_DistributionName;
    $::PREREQS_ATTR{'DistributionVersion'} = NodeUtils->get_DistributionVersion;

    # Pacakge Defines

    # management server
    %::Svrpkgdefs =
      ServerUtils->get_pkgdefs(
                               $::PREREQS_ATTR{'OSName'},
                               $::PREREQS_ATTR{'DistributionName'},
                               $::PREREQS_ATTR{'DistributionVersion'},
                               $::PREREQS_ATTR{'PkgArchitecture'},
                               "MgmtServer",
                               $::PREREQS_ATTR{'CsmCoreVersion'}
                               );

    # managed node
    %::Nodepkgdefs =
      ServerUtils->get_pkgdefs(
                               $::PREREQS_ATTR{'OSName'},
                               $::PREREQS_ATTR{'DistributionName'},
                               $::PREREQS_ATTR{'DistributionVersion'},
                               $::PREREQS_ATTR{'PkgArchitecture'},
                               "MgdNode",
                               $::PREREQS_ATTR{'CsmCoreVersion'}
                               );

    # version/release hash for Server and Node package list
    foreach my $k (keys %::Svrpkgdefs)
    {
        if (   ($k eq "director_packages")
            || ($k eq "opensrc_prereqs")
            || ($k eq "csm_packages")
            || ($k eq "os_prereqs")
            || ($k eq "rsct_packages"))
        {
            @::tmp_var_array = (@{$::Svrpkgdefs{$k}});
            foreach my $tmp_var_rpm (@::tmp_var_array)
            {
                my ($my_version, $my_release) =
                  split(/::/,
                        ArchiveUtils->get_definition_version($tmp_var_rpm));
                my @parts = split /-/, $tmp_var_rpm;
                my $basename = shift @parts;
                my $p;
              BNAME: while ($p = shift @parts)    # this sucks
                {
                    if ($p !~ m/^\d/)
                    {    #if it doesn't start with a digit
                        $basename .= "-$p";
                    }
                    else { unshift @parts, $p; last BNAME; }
                }
                my $tmp_var1;
                my $my_rindex = rindex($basename, "*");
                if ($my_rindex != -1)
                {
                    $tmp_var1 = substr($basename, 0, rindex($basename, "*"));
                }
                else { $tmp_var1 = $basename; }
                $my_rindex = rindex($tmp_var1, "-");
                if (($my_rindex + 1) == 0) { $basename = $tmp_var1; }
                elsif (($my_rindex + 1) == length($tmp_var1))
                {
                    $basename = substr($tmp_var1, 0, rindex($tmp_var1, "*"));
                }
                else { $basename = $tmp_var1; }
                $::PackageVersionName_Server{$basename}{'Version'} =
                  $my_version;
                $::PackageVersionName_Server{$basename}{'Release'} =
                  $my_release;
                $::PackageVersionName_Server{$basename}{'FullName'} =
                  $tmp_var_rpm;
            }
        }
    }
    foreach my $k (keys %::Nodepkgdefs)
    {
        if (   ($k eq "director_packages")
            || ($k eq "opensrc_prereqs")
            || ($k eq "csm_packages")
            || ($k eq "os_prereqs")
            || ($k eq "rsct_packages"))
        {
            @::tmp_var_array = (@{$::Nodepkgdefs{$k}});
            foreach my $tmp_var_rpm (@::tmp_var_array)
            {
                my ($my_version, $my_release) =
                  split(/::/,
                        ArchiveUtils->get_definition_version($tmp_var_rpm));
                my @parts = split /-/, $tmp_var_rpm;
                my $basename = shift @parts;
                my $p;
              BNAME: while ($p = shift @parts)
                {
                    if ($p !~ m/^\d/)
                    {    #if it doesn't start with a digit
                        $basename .= "-$p";
                    }
                    else { unshift @parts, $p; last BNAME; }
                }
                my $tmp_var1;
                my $my_rindex = rindex($basename, "*");
                if ($my_rindex != -1)
                {
                    $tmp_var1 = substr($basename, 0, rindex($basename, "*"));
                }
                else { $tmp_var1 = $basename; }
                $my_rindex = rindex($tmp_var1, "-");
                if (($my_rindex + 1) == 0) { $basename = $tmp_var1; }
                elsif (($my_rindex + 1) == length($tmp_var1))
                {
                    $basename = substr($tmp_var1, 0, rindex($tmp_var1, "*"));
                }
                else { $basename = $tmp_var1; }
                $::PackageVersionName_Node{$basename}{"Version"}  = $my_version;
                $::PackageVersionName_Node{$basename}{"Release"}  = $my_release;
                $::PackageVersionName_Node{$basename}{"FullName"} =
                  $tmp_var_rpm;
            }
        }
    }
}

#--------------------------------------------------------------------------------

=head3    set_variables


=cut

#--------------------------------------------------------------------------------

sub set_variables
{

    # installms only runs on Linux systems
    my $OSName = $::PREREQS_ATTR{'OSName'};
    if ($OSName ne "Linux")
    {

        # should never get here
        NodeUtils->message("E2", 'EMsgINVALID_OSTYPE');
    }

    my $temp_distro =
        $::PREREQS_ATTR{'DistributionName'} . " "
      . $::PREREQS_ATTR{'DistributionVersion'};
    if (!grep(/^$temp_distro$/, @::VALID_DISTROS))
    {
        NodeUtils->message('W', 'EMsgUNSUPPORTED_DISTRO',
                           $temp_distro, join(', ', @::VALID_DISTROS));
    }
    else { NodeUtils->message('V', 'IMsgDETECTED_DISTRO', $temp_distro); }
    if (!grep(/^$::PREREQS_ATTR{'CsmCoreVersion'}$/, @::VALID_CSM_DISTROS))
    {
        NodeUtils->message(
                           'E5',
                           'EMsgUNSUPPORTED_CSM_DISTRO',
                           "CSM" . $::PREREQS_ATTR{'CsmCoreVersion'},
                           join(', ', @::VALID_CSM_DISTROS)
                           );
    }
    else
    {
        NodeUtils->message('V', 'IMsgDETECTED_CSM_DISTRO',
                           "CSM" . $::PREREQS_ATTR{'CsmCoreVersion'});
    }

    $::PREREQS_ATTR{'OSTypeVer'} =
        $::PREREQS_ATTR{'OSName'}
      . $::PREREQS_ATTR{'DistributionName'}
      . $::PREREQS_ATTR{'DistributionVersion'};

    # installation path
    $::INSTALLDIR       = "/csminstall";
    $::INSTALLDIR_CSM   = $::INSTALLDIR . "/csm";
    $::INSTALLDIR_CSMVR =
      $::INSTALLDIR_CSM . "/" . $::PREREQS_ATTR{CsmCoreVersion};
    $::INSTALLDIR_CSMVRBIN = $::INSTALLDIR_CSMVR . "/bin";
    $::INSTALLDIR_OS       =
        $::INSTALLDIR . "/"
      . $::PREREQS_ATTR{"OSName"} . "/"
      . $::PREREQS_ATTR{'DistributionName'};
    $::INSTALLDIR_OSVER =
      $::INSTALLDIR_OS . "/" . $::PREREQS_ATTR{DistributionVersion};
    $::INSTALLDIR_OSVER_ARCH =
      $::INSTALLDIR_OSVER . "/" . $::PREREQS_ATTR{'PkgArchitecture'};
    $::INSTALLDIR_OSCSM  = $::INSTALLDIR_OS . "/csm";
    $::INSTALLDIR_CSMVER =
      $::INSTALLDIR_OSCSM . "/" . $::PREREQS_ATTR{CsmCoreVersion};
    my $INSTALLDIR_OS_NAME = $::PREREQS_ATTR{DistributionName};

    if ($::PREREQS_ATTR{DistributionName} =~ /RedHat/)
    {
        $INSTALLDIR_OS_NAME = "RedHat";
    }
    $::INSTALLDIR_OS_NAME_RPMS =
      $::INSTALLDIR_OSVER_ARCH . "/" . $INSTALLDIR_OS_NAME . "/RPMS";
    $::INSTALLDIR_CSMBIN = $::INSTALLDIR_CSMVER . "/bin";
    $::INSTALLDIR_CSMPKG = $::INSTALLDIR_CSMVER . "/packages";

    # package lists

    # open source rpm prereqs

    @::mgmtserver_open_srcrpms = (@{$::Svrpkgdefs{opensrc_prereqs}});
    @::mdgnode_open_srcrpms    = (@{$::Nodepkgdefs{opensrc_prereqs}});
    @::opensrc_rpm_prereqs     =
      (@::mgmtserver_open_srcrpms, @::mdgnode_open_srcrpms);
    @::opensrc_rpm_prereqs =
      ServerUtils->get_uniqu_arry_elemnts(@::opensrc_rpm_prereqs);

    # csm packages

    @::mgmtserver_csm_packages = (@{$::Svrpkgdefs{csm_packages}});
    @::mdgnode_csm_packages    = (@{$::Nodepkgdefs{csm_packages}});
    @::csm_packages = (@::mgmtserver_csm_packages, @::mdgnode_csm_packages);
    @::csm_packages = ServerUtils->get_uniqu_arry_elemnts(@::csm_packages);

    # rsct packages

    @::mgmtserver_rsct_packages = (@{$::Svrpkgdefs{rsct_packages}});
    @::mdgnode_rsct_packages    = (@{$::Nodepkgdefs{rsct_packages}});
    @::rsct_packages = (@::mgmtserver_rsct_packages, @::mdgnode_rsct_packages);
    @::rsct_packages = ServerUtils->get_uniqu_arry_elemnts(@::rsct_packages);

    # director packages

    @::director_packages = (@{$::Svrpkgdefs{director_packages}});

    # operating system prereqs

    @::mgmtserver_os_prereq = (@{$::Svrpkgdefs{os_prereqs}});
    @::mdgnode_os_prereq    = (@{$::Nodepkgdefs{os_prereqs}});

    @::os_prereq = (@::mgmtserver_os_prereq, @::mdgnode_os_prereq);
    @::os_prereq = ServerUtils->get_uniqu_arry_elemnts(@::os_prereq);

    # get sis packages

    #if( ($::DISTRO =~ /SLES/ || $::DISTRO =~/SuSE/ ) && $::PREREQS_ATTR{'PkgArchitecture'}=~/i?86/ )
    #{
    #@::mgmtserver_sis_packages = (@{$::Svrpkgdefs{sis_packages}});
    #@::mdgnode_sis_packages = (@{$::Nodepkgdefs{sis_packages}});

    #@::sis_packages = (@::mgmtserver_sis_packages, @::mdgnode_sis_packages);
    #@::sis_packages = ServerUtils->get_uniqu_arry_elemnts(@::sis_packages);
    #}

    # CSM binaries copied to /csminstall/csm directory

    @::csm_bin_file_csm = (@{$::Svrpkgdefs{csm_bin_copy_csm}});

    # CSM binaries copied to /tftpboot directory

    @::csm_bin_file_tftpboot = (@{$::Svrpkgdefs{csm_bin_copy_tftpboot}});

    # default csm tftp server

    @::default_tftp_server_name =
      (@{$::Svrpkgdefs{default_tftp_server_pkg_name}});

    # Populate the version release of definition hash

    foreach my $tmp_var_rpm (@::opensrc_rpm_prereqs, @::csm_packages,
                             @::rsct_packages, @::director_packages,
                             @::os_prereq)
    {
        my ($my_version, $my_release) =
          split(/::/, ArchiveUtils->get_definition_version($tmp_var_rpm));
        my @parts = split /-/, $tmp_var_rpm;
        my $basename = shift @parts;
        my $p;
      BNAME: while ($p = shift @parts)
        {
            if ($p !~ m/^\d/)
            {    #if it doesn't start with a digit
                $basename .= "-$p";
            }
            else { unshift @parts, $p; last BNAME; }
        }
        my $tmp_var1;
        my $my_rindex = rindex($basename, "*");
        if ($my_rindex != -1)
        {
            $tmp_var1 = substr($basename, 0, rindex($basename, "*"));
        }
        else { $tmp_var1 = $basename; }
        $my_rindex = rindex($tmp_var1, "-");
        if (($my_rindex + 1) == 0) { $basename = $tmp_var1; }
        elsif (($my_rindex + 1) == length($tmp_var1))
        {
            $basename = substr($tmp_var1, 0, rindex($tmp_var1, "*"));
        }
        else { $basename = $tmp_var1; }
        $::PackageVersionName{$basename}{'Version'}  = $my_version;
        $::PackageVersionName{$basename}{'Release'}  = $my_release;
        $::PackageVersionName{$basename}{'FullName'} = $tmp_var_rpm;
    }
}

#--------------------------------------------------------------------------------

=head3    usage

        Notes:

=cut

#--------------------------------------------------------------------------------

sub usage
{

    NodeUtils->message('I', 'IMsginstallmsUsage', join(' ', @::VALID_ATTRS));
    exit 1;
}

#--------------------------------------------------------------------------------

=head3    getArgs

        Notes:

=cut

#--------------------------------------------------------------------------------

sub getArgs
{
    my @command_line = ();
    @command_line   = @ARGV;
    $::command_line = $0 . " " . join(" ", @command_line);

    my $my_dir = NodeUtils->runcmd("pwd");
    chomp($my_dir);
    if ($my_dir =~ /$::MNTCDROM/)
    {
        NodeUtils->message('E1', 'IMsgCHANGE_TO_NON_CDROM_DRIVE', $my_dir);
        exit 1;
    }

    my $pkgpath = "";

    if (!getopts('p:cfxvVh')) { &usage; }
    if ($::opt_h)             { &usage }

    $::DONT_COPY_RPMS = $::opt_x;
    $::FORCE_INSTALL  = $::opt_f;
    $::COPY_OPT_FLAG  = $::opt_c;

    if ($::opt_v || $::opt_V)
    {
        if ($::opt_v) { $::VERBOSE = $::opt_v; }
        if ($::opt_V) { $::VERBOSE = $::opt_V; }

    }

    if ($::opt_x && $::opt_p) { &usage; }
    if (!($::opt_p ^ $::opt_x)) { &usage; }

    # Packages path
    if ($::opt_p) { $pkgpath = $::opt_p; }

    # Handle attr=value arguments
    if (scalar(@ARGV) > 0)
    {
        foreach my $a (@ARGV)
        {

            # allow a null attr values
            my ($attr, $value) = $a =~ /^\s*(\S+?)\s*=\s*(\S*.*)$/;

            if (!length($value)) { $value = "''"; }

            if (!defined($attr))
            {
                NodeUtils->message('W', 'EMsgBAD_ATTR_VAL_FORM');
                &usage;
            }
            my $found = 0;
            foreach my $va (@::VALID_ATTRS)
            {
                if ($attr =~ /^$va$/i)
                {

                    # Put quotes around the value to protect spaces
                    # or weird chars
                    $::ATTRS{$va} = $value;    # Quotes mess up some values
                    $found = 1;
                }
            }
            if (!$found)
            {
                NodeUtils->message('E', 'EMsgBAD_ATTR', $attr);
                NodeUtils->message('I', 'IMsgVALID_ATTRS',
                                   join('\n\t', @::VALID_ATTRS));
                exit 1;
            }
        }
    }

    # Validate attributes and flags
    my $distro =
        $::PREREQS_ATTR{'DistributionName'} . " "
      . $::PREREQS_ATTR{'DistributionVersion'};

    if (!grep(/^$distro$/, @::VALID_DISTROS))
    {
        NodeUtils->message('W', 'EMsgUNSUPPORTED_DISTRO',
                           $distro, join(', ', @::VALID_DISTROS));
    }
    else { NodeUtils->message('V', 'IMsgDETECTED_DISTRO', $distro); }
    $::DISTRO = $distro;

    @::PKGPATH = split(":", $pkgpath);

    # Gather the subdirectories
    foreach my $p (split(":", $pkgpath))
    {
        push @::PKGPATH, (ServerUtils->returnSubdirectory($p));
    }

}

#--------------------------------------------------------------------------------

=head3    process_IBMJava

        Notes:

	Special processing for IBMJava.  If IBMJava2-SDK is already installed
	on the system then don't install IBMJava2-JRE rpm.

	Note that the $rpm variable contains the JRE version number at the end.
	This ensures that we always use the correct version.

	version numbers are hard-coded in this routine

=cut

#--------------------------------------------------------------------------------

sub process_IBMJava
{
    my ($rpm, $my_location, $my_fullname) = @_;
    my $SDK_rpm;
    my $high_version_flag      = 0;
    my $already_installed_flag = 0;
    my $update_flag            = 0;
    my $packager_name_flag     = 0;
    my $already_installed_name;
    my ($name, $version, $release, $arch, $packager_name);

    my $my_version = $::PackageVersionName_Server{$rpm}{'Version'};

    #if ($my_fullname=~/IBMJava2-JRE-(\d\.\d*\.\d*)/) {
    #	$my_version=$1;
    #} else {
    #	$my_version="1.4.1"; #default 1.4.1
    #}

    ($SDK_rpm = $rpm) =~ s/IBMJava2-JRE/IBMJava2-SDK/;

    my @outout =
      NodeUtils->runcmd(
        "$::RPMCMD -q --qf '%{Name}::%{Version}::%{Release}::%{Arch}::%{Vendor}\n' $rpm",
        -1
        );
    foreach my $i (@outout)
    {
        if (!($i =~ /.*::.*::.*::.*::.*/)) { next; }
        ($name, $version, $release, $arch, $packager_name) = split(/::/, $i);
        if (ArchiveUtils->testVersion($version, ">", $my_version))
        {
            $high_version_flag      = 1;
            $already_installed_name = $name . "-" . $version . "-" . $release;
        }
        elsif (ArchiveUtils->testVersion($version, "=", $my_version))
        {
            $already_installed_flag = 1;
        }
        elsif (ArchiveUtils->testVersion($version, "<", $my_version))
        {
            $update_flag = 1;
        }
        if (   ($packager_name !~ /International Business Machines/)
            && ($packager_name !~ /UnitedLinux/))
        {
            $packager_name_flag = 1;
        }

    }
    @outout =
      NodeUtils->runcmd(
        "$::RPMCMD -q --qf '%{Name}::%{Version}::%{Release}::%{Arch}::%{Vendor}\n' $SDK_rpm",
        -1
        );
    foreach my $i (@outout)
    {
        if (!($i =~ /.*::.*::.*::.*::.*/)) { next; }
        ($name, $version, $release, $arch, $packager_name) = split(/::/, $i);
        if (ArchiveUtils->testVersion($version, ">", $my_version))
        {
            $high_version_flag      = 1;
            $already_installed_name = $name . "-" . $version . "-" . $release;
        }
        elsif (ArchiveUtils->testVersion($version, "=", $my_version))
        {
            $already_installed_flag = 1;
        }
        elsif (ArchiveUtils->testVersion($version, "<", $my_version))
        {
            $update_flag = 1;
        }
        if (   ($packager_name !~ /International Business Machines/)
            && ($packager_name !~ /UnitedLinux/))
        {
            $packager_name_flag = 1;
        }
    }

    # check for packager name flag for already installed rpm
    if ($packager_name_flag == 1)
    {
        NodeUtils->message('E1', 'EMsgUnsupportedRpmName', $rpm, $packager_name,
                           $rpm);
    }
    @outout =
      NodeUtils->runcmd(
        "$::RPMCMD -qp --qf '%{Name}::%{Version}::%{Release}::%{Arch}::%{Vendor}\n' $my_location/$my_fullname",
        -1
        );
    foreach my $i (@outout)
    {
        if (!($i =~ /.*::.*::.*::.*::.*/)) { next; }
        ($name, $version, $release, $arch, $packager_name) = split(/::/, $i);
        if (   ($packager_name !~ /International Business Machines/)
            && ($packager_name !~ /UnitedLinux/))
        {
            $packager_name_flag = 1;
        }
        if (ArchiveUtils->testVersion($version, ">", $my_version))
        {
            NodeUtils->message('E1', 'EMsgNoRpmFound', $name);
        }
    }

    # return 2 = already installed
    # return 1 = higher version installed, install with the --oldpackage option
    # return 0 = package not installed
    # check for packager name flag for already installed rpm
    if ($packager_name_flag == 1)
    {
        NodeUtils->message('E1', 'EMsgNoRpmFound', $name);
    }
    if ($high_version_flag == 1)
    {
        if ($already_installed_flag == 1)
        {
            if ($::FORCE_INSTALL) { return 0; }
            else { return 2; }
        }
        elsif ($update_flag == 1)
        {
            if ($::FORCE_INSTALL) { return 0; }
            else { return 0; }
        }
        else
        {
            if (   $::PREREQS_ATTR{'DistributionName'} =~ /SuSE/
                || $::PREREQS_ATTR{'DistributionName'} =~ /SLES/)
            {
                NodeUtils->messageFromCat(
                                'csmInstall.cat',        $::MSGMAPPATH,
                                'csminstall',            'E2',
                                'EMsgRPMWrongVersion',   $rpm,
                                $already_installed_name, $already_installed_name
                                );
            }
            else { return 1; }
        }
    }
    elsif ($already_installed_flag == 1)
    {
        if ($::FORCE_INSTALL) { return 0; }
        else { return 2; }
    }
    elsif ($update_flag == 1)
    {
        if ($::FORCE_INSTALL) { return 0; }
        else { return 0; }
    }
    else { return 0; }
}

#--------------------------------------------------------------------------------

=head3    arrange_rpm

        Notes: move to ArchiveUtils

	Arranges the rpm array in order of the installed

=cut

#--------------------------------------------------------------------------------

sub arrange_rpm
{
    my (@rpm_array)     = @_;
    my @temp_array      = ();
    my @shortname_array = ();
    my %temp_hash       = ();

    #get the shortname of the rpm
    foreach my $rpm_name (@rpm_array)
    {
        my @parts = split /-/, $rpm_name;
        my $shortname = shift @parts;
        my $p;
      SNAME: while ($p = shift @parts)
        {
            if ($p !~ m/^\d/)
            {    #if it doesn't start with a digit
                $shortname .= "-$p";
            }
            else { unshift @parts, $p; last SNAME; }
        }
        my $tmp_var1;
        my $my_rindex = rindex($shortname, "*");
        if ($my_rindex != -1)
        {
            $tmp_var1 = substr($shortname, 0, rindex($shortname, "*"));
        }
        else { $tmp_var1 = $shortname; }
        $my_rindex = rindex($tmp_var1, "-");
        if (($my_rindex + 1) == 0) { $shortname = $tmp_var1; }
        elsif (($my_rindex + 1) == length($tmp_var1))
        {
            $shortname = substr($tmp_var1, 0, rindex($tmp_var1, "*"));
        }
        else { $shortname = $tmp_var1; }
        push(@shortname_array, $shortname);
    }

    foreach my $rpm (@::Rpms_to_be_installed) { $temp_hash{$rpm}++; }
    foreach my $rpm (@shortname_array)
    {
        if (exists($temp_hash{$rpm})) { push(@temp_array, $rpm); }
    }

    @::Rpms_to_be_installed = @temp_array;
}

#--------------------------------------------------------------------------------

=head3    install_rpm_Linux

        Notes: move to ArchiveUtils - this is huge...

	This is the new install rpm , which does the rpm installation bases on
	the new list - currently it supports only Linux

=cut

#--------------------------------------------------------------------------------

sub install_rpm_Linux
{
    my ($flag) = @_;
    my ($flags, $installflag, @my_path);
    if (!$installflag) { $installflag = "-U"; }    # Default to -U
    @my_path = ($::INSTALLDIR_CSMPKG, $::INSTALLDIR_OS_NAME_RPMS);

    # check if there are any rpms not found, if exists than exit
    if (scalar(@::Rpms_not_found) >= 1)
    {
        my @rpm_ignored     = ();
        my @rpm_not_ignored = ();
        foreach my $rpm_name (@::Rpms_not_found)
        {
            if ($rpm_name =~ m/fping/) { push(@rpm_ignored, $rpm_name); }
            elsif ($rpm_name =~ m/tftp/)
            {

                # see if some tftp server is installed:
                my ($isDefault, @tftpServers) =
                  NetworkUtils->check4InstalledTftpServers();
                if ($#tftpServers eq -1 && !$isDefault)
                {
                    MessageUtils->message('W', 'IMsgNoDefaultTFTPServerFound',
                                          @::default_tftp_server_name);
                }
            }
            else { push(@rpm_not_ignored, $rpm_name); }
        }

        # Ignore all SIS packages
        if (scalar(@rpm_not_ignored) > 0)
        {
            my $rpm_temp;
            my @rpm_not_found;
            foreach $rpm_temp (@rpm_not_ignored)
            {
                my $short_rpm;
                my $my_rindex = rindex($rpm_temp, "*");
                if ($my_rindex != -1)
                {
                    $short_rpm = substr($rpm_temp, 0, $my_rindex);
                }

                #my @foo = grep(/$short_rpm/, @::sis_packages);
                #if (scalar(@foo)) {
                #	push (@rpm_ignored,$rpm_temp);
                #	$::IGNORE_SIS = 1;
                #}
                #else {
                push(@rpm_not_found, $rpm_temp);

                #}
            }
            @::Rpms_not_found = @rpm_not_found;
        }
        else
        {
            @::Rpms_not_found = @rpm_not_ignored;
        }

        if (scalar(@rpm_ignored) > 0)
        {
            NodeUtils->message('I', 'IMsgMissingRPM', join(", ", @rpm_ignored));
        }
        if (scalar(@::Rpms_not_found) >= 1)
        {
            NodeUtils->message('E1', 'EMsgNoRpmFound',
                               join(", ", @::Rpms_not_found));
        }
    }
    if (scalar(@::Rpms_already_installed) >= 1)
    {
        foreach my $temp_rpm_name (@::Rpms_already_installed)
        {

            # below one line  for Special condition for IBMJava
            if ($temp_rpm_name =~ /^IBMJava2-JRE/) { next; }
            NodeUtils->message('I', 'IMsgRPM_ALREADY_INSTALLED',
                               $temp_rpm_name);
        }
    }

    #check if any rpms need to be installed
    if (scalar(@::Rpms_to_be_installed) >= 1)
    {

        if (  (grep /rsct/, @::Rpms_to_be_installed) > 0 ) {

            # if this is the rsct list then install them all at once
            my ($rpmlist, $cmd);
            my ($location, $destination, $full_name);

            foreach my $my_rpm (@::Rpms_to_be_installed) {
                $full_name = $::Rpm_name_path{$my_rpm}{'BaseName'};
                $location  = $::Rpm_name_path{$my_rpm}{'Location'};
                $rpmlist .=" $location/$full_name";
                NodeUtils->message('I', 'IMsgINSTALLING_RPMS', $full_name);
            }
            $cmd = "$::RPMCMD $installflag $rpmlist";
            $cmd .= " --force " if $::FORCE_INSTALL;

            NodeUtils->runcmd("$cmd");

        } else {

            #file name =full name of the file including path
            foreach my $my_rpm (@::Rpms_to_be_installed) {
                my ($location, $destination, $full_name);
                $full_name = $::Rpm_name_path{$my_rpm}{'BaseName'};
                $location  = $::Rpm_name_path{$my_rpm}{'Location'};

                #Install the Rpm dependencies
                ArchiveUtils->installRequiredRpms($my_rpm, @my_path);

                # Special processing for open source rpms install
                if ($flag) {

                    #Special process for conserver
                    if ($my_rpm =~ /conserver/) {
                        my $conserverinstallflag =
                           &processConsever($location . "/" . $full_name,
                                       $my_path[0]);
                        if ($conserverinstallflag == 0)
                        {
                            next;
                        }    # conserver is installed.
                    }
                    if ($my_rpm =~ /tftp/)
                    {
                        my $rc = NetworkUtils->process_tftp();
                        if ($rc)
                        {

                            #ArchiveUtils->display_opensrcLicence($my_rpm);
                            #workaround for NLS problem
                            if ($::ENGLISH)
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPM',
                                               $full_name);
                            }
                            else
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPMS',
                                               $full_name);
                            }
                            my $cmd =
                                "$::RPMCMD $installflag $flags $location/$full_name";
                            $cmd = "$cmd --force" if $::FORCE_INSTALL;
                            $rc = NodeUtils->run_cmd($cmd, "W", "show_all");
                            if ($rc eq 0)
                            {
                                $::default_tftp_server_installed = 1;
                                next;
                            }
                            else
                            {
                                exit;
                            }
                        }
                        next;
                    }
                    if ($my_rpm =~ /^IBMJava2-JRE/)
                    {
                        my $rc = &process_IBMJava($my_rpm, $location, $full_name);
                        if ($rc == 0)
                        {
                            ArchiveUtils->display_opensrcLicence($my_rpm);

                            #workaround for NLS problem
                            if ($::ENGLISH)
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPM',
                                               $full_name);
                            }
                            else
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPMS',
                                               $full_name);
                            }
                            my $cmd =
                          "$::RPMCMD $installflag $flags $location/$full_name";
                            $cmd = "$cmd --force" if $::FORCE_INSTALL;
                            NodeUtils->runcmd("$cmd");

                            #SuSE changes
                            #In SuSE8.1 and SLES8, after installing IBMJava2-JRE-1.3, should comment "export LD_ASSUME_KERNEL=2.2.5"
                            if (
                            (
                                $::PREREQS_ATTR{'DistributionName'} =~ /SuSE/
                             && $::PREREQS_ATTR{'DistributionVersion'} eq '8.1'
                            )
                            || (   $::PREREQS_ATTR{'DistributionName'} =~ /SLES/
                                && $::PREREQS_ATTR{'DistributionVersion'} eq
                                '8.1')
                          )
                            {
                                NodeUtils->runcmd(
                                "/usr/bin/perl -p -i -e 's/^export LD_ASSUME_KERNEL=2.2.5/# export LD_ASSUME_KERNEL=2.2.5/g' /opt/IBMJava2-13/jre/bin/java"
                                );
                            }

                            #End SuSE changes

                            #RedHat 9 changes
                            #In RedHat 9, after installing IBMJava2-JRE-1.3.1, should set "export LD_ASSUME_KERNEL=2.2.5"
                            if (
                            (
                                $::PREREQS_ATTR{'DistributionName'} =~ /RedHat/
                             && $::PREREQS_ATTR{'DistributionVersion'} eq '9'
                            )
                            || ($::PREREQS_ATTR{'DistributionName'} =~
                                /RedHatEL-ES/
                                && $::PREREQS_ATTR{'DistributionVersion'} eq
                                '2.1')
                          )
                            {
                                NodeUtils->runcmd(
                                "/usr/bin/perl -p -i -e 's/^# Run./export LD_ASSUME_KERNEL=2.2.5/' /opt/IBMJava2-131/jre/bin/java"
                                );
                            }

                            #End
                            next;
                        }
                        elsif ($rc == 1)
                        {
                            ArchiveUtils->display_opensrcLicence($my_rpm);

                            #workaround for NLS problem
                            if ($::ENGLISH)
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPM',
                                               $full_name);
                            }
                            else
                            {
                                NodeUtils->message('I', 'IMsgINSTALLING_RPMS',
                                               $full_name);
                            }
                            $installflag = "-i";
                            $flags       = "--oldpackage";
                            my $cmd =
                          "$::RPMCMD $installflag $flags $location/$full_name";
                            $cmd = "$cmd --force" if $::FORCE_INSTALL;
                            NodeUtils->runcmd("$cmd");

                            #SuSE changes
                            #In SuSE8.1 and SLES8, after installing IBMJava2-JRE-1.3, should comment "export LD_ASSUME_KERNEL=2.2.5"
                            if (
                            (
                                $::PREREQS_ATTR{'DistributionName'} =~ /SuSE/
                             && $::PREREQS_ATTR{'DistributionVersion'} eq '8.1'
                            )
                            || (   $::PREREQS_ATTR{'DistributionName'} =~ /SLES/
                                && $::PREREQS_ATTR{'DistributionVersion'} eq
                                '8.1')
                          )
                            {
                                NodeUtils->runcmd(
                                "/usr/bin/perl -p -i -e 's/^export LD_ASSUME_KERNEL=2.2.5/# export LD_ASSUME_KERNEL=2.2.5/g' /opt/IBMJava2-13/jre/bin/java"
                                );
                            }

                            #End SuSE changes
                            #RedHat 9 changes
                            #In RedHat 9, after installing IBMJava2-JRE-1.3.1, should set "export LD_ASSUME_KERNEL=2.2.5"
                            if (
                            (
                                $::PREREQS_ATTR{'DistributionName'} =~ /RedHat/
                             && $::PREREQS_ATTR{'DistributionVersion'} eq '9'
                            )
                            || ($::PREREQS_ATTR{'DistributionName'} =~
                                /RedHatEL-ES/
                                && $::PREREQS_ATTR{'DistributionVersion'} eq
                                '2.1')
                          )
                            {
                                NodeUtils->runcmd(
                                "/usr/bin/perl -p -i -e 's/^# Run./export LD_ASSUME_KERNEL=2.2.5/' /opt/IBMJava2-131/jre/bin/java"
                                );
                            }

                            #End
                            next;
                        }
                        else
                        {
                            NodeUtils->message('I', 'IMsgRPM_ALREADY_INSTALLED',
                                           $my_rpm);
                            next;
                        }
                    }
                    if (grep(/^$my_rpm$/, @::GPL_PACKAGES)
                    and !$::DISPLAYED_GPL_LICENSE)
                    {
                        ArchiveUtils->display_opensrcLicence($my_rpm);
                    }
                    if ($my_rpm =~ /^openCIMOM/)
                    {

                        #workaround for NLS problem
                        if ($::ENGLISH)
                        {
                            NodeUtils->message('I', 'IMsgINSTALLING_RPM',
                                           $full_name);
                        }
                        else
                        {
                            NodeUtils->message('I', 'IMsgINSTALLING_RPMS',
                                           $full_name);
                        }
                        $flags = "--oldpackage";
                        if ($::rpm_pkg_flag{openCIMOM})
                        {
                            $flags = $flags . " " . $::rpm_pkg_flag{openCIMOM};
                        }
                        my $cmd =
                      "$::RPMCMD $installflag $flags $location/$full_name";
                        $cmd = "$cmd --force" if $::FORCE_INSTALL;
                        NodeUtils->runcmd("$cmd");
                        next;
                    }
                }

                #workaround for NLS problem
                if ($::ENGLISH)
                {
                    NodeUtils->message('I', 'IMsgINSTALLING_RPM', $full_name);
                }
                else
                {
                    NodeUtils->message('I', 'IMsgINSTALLING_RPMS', $full_name);
                }

                my $cmd = "$::RPMCMD $installflag $flags $location/$full_name";
                $cmd = "$cmd --force" if $::FORCE_INSTALL;

                # More special processing for conserver.  For some reason, when conserver
                # is upgraded from 7.2.2* to 7.2.4, the rpm command hangs if it is run
                # in backticks(``), as is done in NodeUtils->runcmd.  It works fine when
                # run from system().
                if (grep /conserver/, $full_name)
                {
                    NodeUtils->message('V', 'IMsgCMD', $cmd);
                    system("$cmd");
                }
                else
                {
                    if (   (grep /nfs-utils/, $full_name)
                    || (grep /XFree86-libs/, $full_name))
                    {
                        NodeUtils->runcmd("$cmd", 0);
                    }
                    else { NodeUtils->runcmd("$cmd"); }
                }
            }
        }
    }
}

#--------------------------------------------------------------------------------

=head3    install_packages_Linux

        Notes: move to ArchiveUtils

	This is the new install packages, which call the new install rpm.
	Currently it supports only Linux.

=cut

#--------------------------------------------------------------------------------

sub install_packages_Linux
{
    my ($rpm, $tarball_list, $cmd, $rc, $returncode);
    my @linux_prereqs;
    $rc         = 0;
    $returncode = 0;

    #SuSE Changes
    NodeUtils->message("I", 'IMsgINSTALLING_RPMS', "LINUX OS PRE REQUISITIES");

    # collect the rpms name those are  eligible
    ArchiveUtils->search_rpm_csminstall_path(@::mgmtserver_os_prereq);
    ArchiveUtils->create_rpm_list_to_install();
    &arrange_rpm(@::mgmtserver_os_prereq);
    &install_rpm_Linux();

    #End of SuSE Changes

    NodeUtils->message("I", 'IMsgINSTALLING_RPMS',
                       "OPEN SOURCE PRE REQUISITIES");

    # This is the list of GPL open source packages to be installed.  If any
    # of these packages must be installed, a license is displayed first
    # and the user must press Enter to accept the license.
    if ($::PREREQS_ATTR{'PkgArchitecture'} =~ /ppc64/)
    {
        @::GPL_PACKAGES = ('');
    }
    else
    {
        @::GPL_PACKAGES = ('syslinux');
    }

    # This variable is set when the GPL license has been displayed once,
    # and prevents the license question from being displayed again.
    $::DISPLAYED_GPL_LICENSE = 0;

    # collect the rpms name those are  eligible
    # Remove the director rpms from the  mgmtserver_open_srcrpms array
    # These rpms need to be copied only. They are going to be installed
    # by addlcsext command
    my @temp_aaray = ();
    foreach my $my_temp_rpm (@::mgmtserver_open_srcrpms)
    {
        if (   (grep /ITDAgent/, $my_temp_rpm)
            || (grep /DirAgent/, $my_temp_rpm)
            || (grep /RAIDLxAg/, $my_temp_rpm)
            || (grep /MPAAgent/, $my_temp_rpm))
        {
        }
        else { 
            # ignore packages which has been installed
            my $found = 0;
            foreach (@::RpmsNotBeCopied){
                if($my_temp_rpm eq $_){
                    $found = 1; last;
                }
            }
            next if($found);
            push(@temp_aaray, $my_temp_rpm);
	    }
    }
    @::mgmtserver_open_srcrpms = @temp_aaray;

    ArchiveUtils->search_rpm_csminstall_path(@::mgmtserver_open_srcrpms);
    ArchiveUtils->create_rpm_list_to_install();

    # Special condition for IBMJava, and tftp Begin
    push(@::Rpms_to_be_installed, "IBMJava2-JRE");
    @::Rpms_to_be_installed =
      ServerUtils->get_uniqu_arry_elemnts(@::Rpms_to_be_installed);

    # Special condition for IBMJava End
    &arrange_rpm(@::mgmtserver_open_srcrpms);
    &install_rpm_Linux(1);

    NodeUtils->message('I', 'IMsgINSTALLING_RPMS', "RSCT");

    #check if the rsct.basic is installed or not, if not installed
    # then remove rsct.basic from the list
    NodeUtils->runcmd("$::RPMCMD -q rsct.basic", -1);
    if ($::RUNCMD_RC == 1)
    {
        my @temp_arry = ();
        foreach my $temp_element (@::mgmtserver_rsct_packages)
        {
            if ($temp_element !~ /rsct.basic/)
            {
                push(@temp_arry, $temp_element);
            }
        }
        @::mgmtserver_rsct_packages = @temp_arry;
    }

    # collect the rpms name those are  eligible
    ArchiveUtils->search_rpm_csminstall_path(@::mgmtserver_rsct_packages);
    ArchiveUtils->create_rpm_list_to_install();
    &arrange_rpm(@::mgmtserver_rsct_packages);
    &install_rpm_Linux();

    # TO DO: if rsct.core was already installed, but ctrmc was not started,
    # this would have to time out before continuing
    # &waitForERRM();  -- this is now done in csmserverposti

    NodeUtils->message('I', 'IMsgINSTALLING_RPMS', "CSM");

    # collect the rpms name those are  eligible
    ArchiveUtils->search_rpm_csminstall_path(@::mgmtserver_csm_packages);
    ArchiveUtils->create_rpm_list_to_install();
    # check if Migration install from lower level CSM
    my $preVersion = NodeUtils->runcmd("$::RPMCMD -q csm.server --qf '%{VERSION}'", -1);
    if ($::RUNCMD_RC == 0)
    {
        NodeUtils->runcmd("/usr/bin/chrsrc-api -s IBM.DmsCtrl::::MigrationInfo::$preVersion",-1);
    }
    # added end

    &arrange_rpm(@::mgmtserver_csm_packages);
    &install_rpm_Linux();

    # install SIS PACKAGES in SuSE and SLES
    #if( ( $::DISTRO =~ /SLES/ || $::DISTRO =~/SuSE/ ) && $::PREREQS_ATTR{'PkgArchitecture'}=~/i?86/ )
    #{
    #    NodeUtils->message('I', 'IMsgINSTALLING_RPMS', "SIS");
    #	ArchiveUtils->search_rpm_csminstall_path(@::mgmtserver_sis_packages);
    #ArchiveUtils->create_rpm_list_to_install();
    #&arrange_rpm(@::mgmtserver_sis_packages);
    #    &install_rpm_Linux();
    #}

}

#--------------------------------------------------------------------------------

=head3   set_cluster_attrs

        Notes: move to ServerUtls? Big routine...

	Set global cluster attributes by using ATTR=Value provided by the user.
	This set attributes in the dmsctrl resource class.  The attributes are stored
	in the %::ATTRS hash.

=cut

#--------------------------------------------------------------------------------

sub set_cluster_attrs
{
    my $rc = 0;
    my ($attr, $value, $dmsctrlkey);

    return 0 if (!(keys %::ATTRS));

    my $cmd = "/opt/csm/bin/csmconfig";

    foreach $attr (keys %::ATTRS)
    {
        $value = $::ATTRS{$attr};
        $cmd .= " $attr=$value";
    }

    my $output = NodeUtils->runcmd($cmd, 0);
    $rc = $::RUNCMD_RC;

    return $rc;
}

#--------------------------------------------------------------------------------

=head3    processConsever

        Notes: 

	Process for conserver
	return 1....Install
	return 0....Already Installed

=cut

#--------------------------------------------------------------------------------

sub processConsever
{
    my ($conserrpmfile, $myConserverPathName) = @_;
    my $conserverSpecialinstallflag = 0;
    my $req_ver                     = "7.2.2";
    my $req_rel                     = "6";
    my $conserveroutput             = "";
    my @temp_array                  = ();
    my ($curr_rel, $curr_ver, $ins_rel, $ins_ver);

    # get the version and release of the copied rpm
    (@temp_array) = ArchiveUtils->getRPMVersionRelease($conserrpmfile, 1);
    $curr_ver = $temp_array[0];
    $curr_rel = $temp_array[1];

    # get the version and release valus of the installed rpm
    $conserveroutput = NodeUtils->runcmd("$::RPMCMD -q conserver", -1);
    if ($::RUNCMD_RC != 0)
    {
        if (
            ArchiveUtils->testVersion($curr_ver, "<", $req_ver,
                                      $curr_rel, $req_rel)
          )
        {
            NodeUtils->message('E1', 'EMsgMinConserverNot',
                               $myConserverPathName);
        }
        else
        {
            return 1;
        }
    }
    else
    {
        (@temp_array) = ArchiveUtils->getRPMVersionRelease($conserveroutput);
        $ins_ver = $temp_array[0];
        $ins_rel = $temp_array[1];

        # First set
        if (
            ArchiveUtils->testVersion($ins_ver, ">", $curr_ver,
                                      $ins_rel, $curr_rel)
          )
        {
            if (
                ArchiveUtils->testVersion(
                                     $ins_ver, ">", $req_ver, $ins_rel, $req_rel
                )
              )
            {
                return 1;
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, "<", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                NodeUtils->message('E1', 'EMsgMinConserverNot',
                                   $myConserverPathName);
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, "=", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }
        elsif (
               ArchiveUtils->testVersion(
                                   $ins_ver, "<", $curr_ver, $ins_rel, $curr_rel
               )
          )
        {
            if (
                ArchiveUtils->testVersion(
                                     $ins_ver, "<", $req_ver, $ins_rel, $req_rel
                )
              )
            {
                if (
                    ArchiveUtils->testVersion(
                                   $curr_ver, "=", $req_ver, $curr_rel, $req_rel
                    )
                  )
                {
                    $conserverSpecialinstallflag = 1;
                    goto CONSER;
                }
                elsif (
                       ArchiveUtils->testVersion(
                                   $curr_ver, ">", $req_ver, $curr_rel, $req_rel
                       )
                  )
                {
                    $conserverSpecialinstallflag = 1;
                    goto CONSER;
                }
                elsif (
                       ArchiveUtils->testVersion(
                                   $curr_ver, "<", $req_ver, $curr_rel, $req_rel
                       )
                  )
                {
                    NodeUtils->message('E1', 'EMsgMinConserverNot',
                                       $myConserverPathName);
                }
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, ">", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                if (
                    ArchiveUtils->testVersion(
                                   $curr_ver, ">", $req_ver, $curr_rel, $req_rel
                    )
                  )
                {
                    return 1;
                }
                else
                {
                    NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                       "conserver");
                    return 0;
                }
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, "=", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                return 1;
            }

        }
        elsif (
               ArchiveUtils->testVersion(
                                   $ins_ver, "=", $curr_ver, $ins_rel, $curr_rel
               )
          )
        {
            if (
                ArchiveUtils->testVersion(
                                     $ins_ver, ">", $req_ver, $ins_rel, $req_rel
                )
              )
            {
                return 1;
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, "<", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                NodeUtils->message('E1', 'EMsgMinConserverNot',
                                   $myConserverPathName);
            }
            elsif (
                   ArchiveUtils->testVersion(
                                     $ins_ver, "=", $req_ver, $ins_rel, $req_rel
                   )
              )
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }

        # Set 2
        if (
            ArchiveUtils->testVersion($curr_ver, ">", $req_ver,
                                      $curr_rel, $req_rel)
          )
        {
            if (
                ArchiveUtils->testVersion(
                                   $curr_ver, ">", $ins_ver, $curr_rel, $ins_rel
                )
              )
            {
                if (
                    ArchiveUtils->testVersion(
                                     $ins_ver, "<", $req_ver, $ins_rel, $req_rel
                    )
                  )
                {
                    $conserverSpecialinstallflag = 1;
                    goto CONSER;
                }
                else
                {
                    return 1;
                }
            }
            else
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }
        elsif (
               ArchiveUtils->testVersion(
                                   $curr_ver, "<", $req_ver, $curr_rel, $req_rel
               )
          )
        {
            NodeUtils->message('E1', 'EMsgMinConserverNot',
                               $myConserverPathName);
        }
        elsif (
               ArchiveUtils->testVersion(
                                   $curr_ver, "=", $req_ver, $curr_rel, $req_rel
               )
          )
        {
            if (
                ArchiveUtils->testVersion(
                                   $curr_ver, "<", $ins_ver, $curr_rel, $ins_rel
                )
              )
            {
                $conserverSpecialinstallflag = 1;
                goto CONSER;
            }
            else
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }

        # Set 3
        if (
            ArchiveUtils->testVersion($req_ver, ">", $ins_ver,
                                      $req_rel, $ins_rel)
          )
        {
            if (
                ArchiveUtils->testVersion(
                                   $req_ver, ">", $curr_ver, $req_rel, $curr_rel
                )
              )
            {
                NodeUtils->message('E1', 'EMsgMinConserverNot',
                                   $myConserverPathName);
            }
            else
            {
                $conserverSpecialinstallflag = 1;
                goto CONSER;
            }
        }
        elsif (
               ArchiveUtils->testVersion(
                                     $req_ver, "<", $ins_ver, $req_rel, $ins_rel
               )
          )
        {
            if (
                ArchiveUtils->testVersion(
                                   $curr_ver, ">", $ins_ver, $curr_rel, $ins_rel
                )
              )
            {
                return 1;
            }
            else
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }
        elsif (
               ArchiveUtils->testVersion(
                                     $req_ver, "=", $ins_ver, $req_rel, $ins_rel
               )
          )
        {
            if (
                ArchiveUtils->testVersion(
                                   $req_ver, "<", $curr_ver, $req_rel, $curr_rel
                )
              )
            {
                return 1;
            }
            else
            {
                NodeUtils->message('V', 'IMsgRPM_ALREADY_INSTALLED',
                                   "conserver");
                return 0;
            }
        }
    }
  CONSER:
    if ($conserverSpecialinstallflag == 1)
    {
        my $conSerRandomNumber;
        my $conserver_config_copy_flag = 0;
        if (-f "/etc/opt/conserver/conserver.cf")
        {

            #generating a unique random number file/directory naming purpose
            $conSerRandomNumber = int(rand(2000)) + 1000;
            while (-d "/tmp/$conSerRandomNumber")
            {
                $conSerRandomNumber = int(rand(2000)) + 1000;
            }
            mkpath("/tmp/$conSerRandomNumber", $::VERBOSE, 0755);
            NodeUtils->runcmd(
                "$::COPY /etc/opt/conserver/conserver.cf /tmp/$conSerRandomNumber/"
                );
            $conserver_config_copy_flag = 1;
        }
        NodeUtils->runcmd("$::RPMCMD -e conserver --nodeps");
        if ($conserver_config_copy_flag == 1)
        {
            mkpath("/etc/opt/conserver", $::VERBOSE, 0755);
            NodeUtils->runcmd(
                "$::COPY /tmp/$conSerRandomNumber/conserver.cf /etc/opt/conserver/"
                );
            NodeUtils->runcmd("$::RM -rf /tmp/$conSerRandomNumber/");
        }
        return 1;
    }

}

#--------------------------------------------------------------------------------

=head3    checkPreviousInstallation

        Notes:
 		 empty subroutine

=cut

#--------------------------------------------------------------------------------

sub checkPreviousInstallation { }

#--------------------------------------------------------------------------------

=head3    Main

        Notes: 

=cut

#--------------------------------------------------------------------------------

{    # main

    my ($rc)         = 0;
    my ($returncode) = 0;

    $::IGNORE_SIS = 0;

    # load the packagedefs and intialize globs
    &initialize();

    # process command line
    &getArgs;

    # start logging
    MessageUtils->start_logging($::INSTALLMSLOG);

    # set and verify local variables
    &set_variables;

    #  determine which rpms are already installed
    InstallUtils->createRPMVersionListAlreadyInstalled();

    # verify that the rpm tool is present.
    ArchiveUtils->checkForRpmTool();

    # create install directory
    ServerUtils->create_directory_structure();

    # copy the appropriate rpms to /csminstall
    if (!$::DONT_COPY_RPMS) # not don't copy
    {

        # update the rpms in the install dir
        ArchiveUtils->update_rpm_packages_to_csminstall;

        # Verify the current installation
        &checkPreviousInstallation;    # empty sub
    }

    # Install the packages.
    $rc = &install_packages_Linux;
    $returncode = $rc if ($rc > $returncode);

    # Set global cluster attributes in the dmsctrl resource class
    $rc         = &set_cluster_attrs;
    $returncode = $rc if ($rc > $returncode);

    # copy the csm command binaries.
    NodeUtils->message('I', 'IMsgCOPYING_CSMBINARIES');
    ServerUtils->copyBinaries;

    # copy customization scripts
    ServerUtils->copy_csm_scripts(0);

    # create tftp user, configure and secure tftpboot
    NetworkUtils->createTftpUser();
    NetworkUtils->configureTftp();
    NetworkUtils->verifyTftp(1);
    NodeUtils->message('I', 'IMsgSecureFiles', '/tftpboot');
    NetworkUtils->secureFilePermissions('/tftpboot', '0110', '0440');

    #  notify success or failure
    if ($returncode == 0)
    {
        NodeUtils->message('I', 'IMsgINSTALLMS_SUCCESSFUL');
    }
    else { NodeUtils->message('E', 'EMsgINSTALLMS_UNSUCCESSFUL', $returncode); }

    # stop logging
    MessageUtils->stop_logging();

    # exit
    exit $returncode;
}
